home *** CD-ROM | disk | FTP | other *** search
/ ADA Programming Guide / ADA Programming Guide.iso / ada_lrm / chapb.doc < prev    next >
Text File  |  1996-01-30  |  11KB  |  332 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6. The following document is a draft  of  the  corresponding  chapter  of  the
  7. version  of  the  Ada  Reference  Manual  produced  in response to the Ansi
  8. Canvass.  It is given a limited circulation  to  Ada  implementers  and  to
  9. other groups contributing comments (according to the conventions defined in
  10. RRM.comments).  This draft should not be referred to in any publication.
  11.  
  12.  
  13.  
  14.                        ANSI-RM-B-v23 - Draft Chapter
  15.  
  16.                       B  Predefined Language Pragmas
  17.                                 version 23
  18.  
  19.                                  83-02-11
  20.  
  21.            This revision has addressed all comments up to #5795
  22.  
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74.  
  75.  
  76.  
  77.                       B. Predefined Language Pragmas
  78.  
  79.  
  80.  
  81. This annex defines the pragmas LIST, PAGE, and OPTIMIZE, and summarizes the
  82. definitions given elsewhere of the remaining language-defined pragmas.
  83.  
  84. Pragma                                   Meaning
  85.  
  86. CONTROLLED     Takes the simple name  of  an  access  type  as  the  single
  87.                argument.   This  pragma  is only allowed immediately within
  88.                the declarative part or package specification that  contains
  89.                the  declaration  of  the access type;  the declaration must
  90.                occur before the pragma.  This pragma is not allowed  for  a
  91.                derived  type.  This pragma specifies that automatic storage
  92.                reclamation must not be performed for objects designated  by
  93.                values of the access type, except upon leaving the innermost
  94.                block statement, subprogram body, or task body that encloses
  95.                the  access  type  declaration,  or  after  leaving the main
  96.                program (see 4.8).
  97.  
  98. ELABORATE      Takes one or more simple names  denoting  library  units  as
  99.                arguments.   This  pragma  is only allowed immediately after
  100.                the  context  clause  of  a  compilation  unit  (before  the
  101.                subsequent  library  unit or secondary unit).  Each argument
  102.                must be the simple name of a library unit mentioned  by  the
  103.                context    clause.    This   pragma   specifies   that   the
  104.                corresponding library unit body must  be  elaborated  before
  105.                the  given  compilation unit.  If the given compilation unit
  106.                is a subunit, the  library  unit  body  must  be  elaborated
  107.                before  the body of the ancestor library unit of the subunit
  108.                (see 10.5).
  109.  
  110. INLINE         Takes one or more names as arguments;  each name  is  either
  111.                the   name  of  a  subprogram  or  the  name  of  a  generic
  112.                subprogram.  This pragma is only allowed at the place  of  a
  113.                declarative   item   in   a   declarative  part  or  package
  114.                specification, or after a library unit in a compilation, but
  115.                before  any  subsequent  compilation  unit.    This   pragma
  116.                specifies  that  the  subprogram  bodies  should be expanded
  117.                inline at each call  whenever possible;  in the  case  of  a
  118.                generic  subprogram,  the  pragma  applies  to  calls of its
  119.                instantiations (see 6.3.2).
  120.  
  121. INTERFACE      Takes a language name and a subprogram  name  as  arguments.
  122.                This  pragma  is allowed at the place of a declarative item,
  123.                and must apply in this case to a subprogram declared  by  an
  124.                earlier  declarative  item  of  the same declarative part or
  125.                package specification.  This pragma is also  allowed  for  a
  126.                library unit;  in this case the pragma must appear after the
  127.  
  128.  
  129.                                    B - 1
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138.                subprogram    declaration,   and   before   any   subsequent
  139.                compilation unit.  This pragma specifies the other  language
  140.                (and  thereby  the  calling  conventions)  and  informs  the
  141.                compiler that an object module  will  be  supplied  for  the
  142.                corresponding subprogram (see 13.9).
  143.  
  144. LIST           Takes one of  the  identifiers  ON  or  OFF  as  the  single
  145.                argument.   This  pragma  is  allowed  anywhere  a pragma is
  146.                allowed.  It specifies that listing of the compilation is to
  147.                be continued or suspended  until  a  LIST  pragma  with  the
  148.                opposite argument is given within the same compilation.  The
  149.                pragma  itself is always listed if the compiler is producing
  150.                a listing.
  151.  
  152. MEMORY_SIZE    Takes a numeric literal as the single argument.  This pragma
  153.                is only allowed at the start of a  compilation,  before  the
  154.                first  compilation  unit  (if  any) of the compilation.  The
  155.                effect of this pragma is to use the value of  the  specified
  156.                numeric  literal  for  the  definition  of  the named number
  157.                MEMORY_SIZE (see 13.7).
  158.  
  159.  
  160.  
  161.  
  162.  
  163.  
  164.  
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176.  
  177.  
  178.  
  179.  
  180.  
  181.  
  182.  
  183.  
  184.  
  185.  
  186.  
  187.  
  188.  
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195.                                    B - 2
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204. OPTIMIZE       Takes one of the identifiers TIME or  SPACE  as  the  single
  205.                argument.   This pragma is only allowed within a declarative
  206.                part and it applies to  the  block  or  body  enclosing  the
  207.                declarative part.  It specifies whether time or space is the
  208.                primary optimization criterion.
  209.  
  210. PACK           Takes the simple name of a  record  or  array  type  as  the
  211.                single  argument. The allowed positions for this pragma, and
  212.                the restrictions on the named type, are governed by the same
  213.                rules as for a representation clause. The  pragma  specifies
  214.                that  storage minimization should be the main criterion when
  215.                selecting the representation of the given type  (see  13.1).
  216.  
  217. PAGE           This pragma has no  argument,  and  is  allowed  anywhere  a
  218.                pragma is allowed.  It specifies that the program text which
  219.                follows  the  pragma  should  start  on  a  new page (if the
  220.                compiler is currently producing a listing).
  221.  
  222. PRIORITY       Takes a static expression of the predefined integer  subtype
  223.                PRIORITY  as  the  single  argument.   This  pragma  is only
  224.                allowed  within  the  specification  of  a  task   unit   or
  225.                immediately  within the outermost declarative part of a main
  226.                program.  It specifies the priority of the task (or tasks of
  227.                the task type) or the priority  of  the  main  program  (see
  228.                9.8).
  229.  
  230. SHARED         Takes the simple name of a variable as the single  argument.
  231.                This  pragma  is  allowed only for a variable declared by an
  232.                object declaration and whose type  is  a  scalar  or  access
  233.                type;   the  variable  declaration  and the pragma must both
  234.                occur  (in  this  order)   immediately   within   the   same
  235.                declarative  part  or  package  specification.   This pragma
  236.                specifies that every read or update of  the  variable  is  a
  237.                synchronization  point for that variable.  An implementation
  238.                must restrict the objects for which this pragma  is  allowed
  239.                to  objects  for  which  each  of  direct reading and direct
  240.                updating is implemented as  an  indivisible  operation  (see
  241.                9.11).
  242.  
  243. STORAGE_UNIT   Takes a numeric literal as the single argument.  This pragma
  244.                is  only  allowed  at the start of a compilation, before the
  245.                first compilation unit (if any)  of  the  compilation.   The
  246.                effect  of  this pragma is to use the value of the specified
  247.                numeric literal for  the  definition  of  the  named  number
  248.                STORAGE_UNIT (see 13.7).
  249.  
  250. SUPPRESS       Takes as arguments the identifier of a check and  optionally
  251.                also  the  name  of  either  an object, a type or subtype, a
  252.                subprogram, a task unit, or a generic unit.  This pragma  is
  253.                only allowed either immediately within a declarative part or
  254.                immediately  within  a package specification.  In the latter
  255.                case, the only allowed form is with a name that  denotes  an
  256.                entity   (or   several   overloaded   subprograms)  declared
  257.                immediately   within   the   package   specification.    The
  258.                permission to omit the given check extends from the place of
  259.  
  260.  
  261.                                    B - 3
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270.                the  pragma  to the end of the declarative region associated
  271.                with the innermost  enclosing  block  statement  or  program
  272.                unit.   For  a  pragma given in a package specification, the
  273.                permission extends to the end of  the  scope  of  the  named
  274.                entity.
  275.  
  276.                If  the  pragma  includes a name, the permission to omit the
  277.                given check is further restricted:  it  is  given  only  for
  278.                operations on the named object or on all objects of the base
  279.                type  of  a  named  type  or  subtype;  for calls of a named
  280.                subprogram;  for activations of  tasks  of  the  named  task
  281.                type;   or for instantiations of the given generic unit (see
  282.                11.7).
  283.  
  284. SYSTEM_NAME    Takes an enumeration literal as the  single  argument.  This
  285.                pragma is only allowed at the start of a compilation, before
  286.                the first compilation unit (if any) of the compilation.  The
  287.                effect of this pragma is to use the enumeration literal with
  288.                the  specified identifier for the definition of the constant
  289.                SYSTEM_NAME.  This pragma is only allowed if  the  specified
  290.                identifier  corresponds  to  one of the literals of the type
  291.                NAME declared in the package SYSTEM (see 13.7).
  292.  
  293.  
  294.  
  295.  
  296.  
  297.  
  298.  
  299.  
  300.  
  301.  
  302.  
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311.  
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319.  
  320.  
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.                                    B - 4
  328.  
  329.  
  330.  
  331.  
  332.